package com.songtech.base.universal.dao.beans;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import com.songtech.base.universal.dao.constant.BeanParamListEnum;
import com.songtech.base.universal.dao.util.GetEntityParamUtil;
import com.songtech.base.universal.dao.util.GetReflectionSqlUtil;

/**
 * 查询条件
 * @param <T>
 */
public class Where {
	// 作为条件的实体对象
	private Object object;
	// beanlist作为查询条件
	private List<BeanParam> paramList;
	// 使用and连接的查询条件
	private List<Conditions<?>> where;
	// limit分页sql语句(不写select和where)(mysql/postgresql)
//	private String limit;
	// order排序sql语句(不写select和where)
	private String orderBy;
	// group的sql语句(不写select和where)
	private String groupBy;
	
	public Where(){}
	
	/**
	 * 构造方法
	 * @param t 作为条件的实体对象
	 */
	public Where(Object t){
		this.object = t;
	}
	
	/**
	 * 构造方法
	 * @param param 作为查询条件的单个字段
	 */
	public Where(BeanParam param){
		if(param != null && !StringUtils.isEmpty(param.getFieldName()) && param.getValue() != null){
			this.paramList = new ArrayList<>();
			this.paramList.add(param);
		}
	}
	
	/**
	 * 构造方法
	 * @param paramList 作为查询条件的多个字段
	 */
	public Where(List<BeanParam> paramList){
		this.paramList = paramList;
	}
	
	/**
	 * 构造方法
	 * @param t 作为条件的实体对象
	 * @param paramList 作为查询条件的多个字段
	 * @param where 使用and连接的查询条件
	 * @param limit limit分页sql语句(不写select和where)(mysql/postgresql)
	 * @param orderBy order排序sql语句(不写select和where)
	 * @param groupBy group的sql语句(不写select和where)
	 */
	public Where(Object t, List<BeanParam> paramList, List<Conditions<?>> where/*, String limit*/, String orderBy, String groupBy){
		this.object = t;
		this.paramList = paramList;
		this.where = where;
//		this.limit = limit;
		this.orderBy = orderBy;
		this.groupBy = groupBy;
	}
	
	/**
	 * 返回查询条件
	 * @param cls
	 * @return Map<String, Object> map
	 * <br>map.get("sql")：只是查询条件，没有加where
	 * <br>map.get("...")：对应查询条件的值
	 */
	public Map<String, Object> toMap(Class<?> cls){
		GetEntityParamUtil getParam = new GetEntityParamUtil();
		List<BeanParam> list = object == null ? null : getParam.getParamByBeanNotEmpty(object, cls);
		Map<String, Object> map = GetReflectionSqlUtil.getBeanParamListToSql(null, list, BeanParamListEnum.WHERE_OBJECT);// 获取beanlist组成的where条件
		map = GetReflectionSqlUtil.getBeanParamListToSql(map, paramList, BeanParamListEnum.WHERE_OBJECT);// 获取bean组成的where条件
		map = GetReflectionSqlUtil.getWhereListToSql(map, where);// 获取wherelist组成的where条件
		StringBuffer sql = new StringBuffer(map.get("sql").toString());
		if(!StringUtils.isEmpty(groupBy)){
			sql.append(" " + groupBy);
		}
		if(!StringUtils.isEmpty(orderBy)){
			sql.append(" " + orderBy);
		}
		map.put("sql", sql.toString());
		return map;
	}
	
	/** 作为条件的实体对象 */
	public Object getObject() {
		return object;
	}
	/** 作为条件的实体对象 */
	public void setObject(Object object) {
		this.object = object;
	}
	/** beanlist作为查询条件 */
	public List<BeanParam> getParamList() {
		return paramList;
	}
	/** beanlist作为查询条件 */
	public void setParamList(List<BeanParam> paramList) {
		this.paramList = paramList;
	}
	/** 使用and连接的查询条件 */
	public List<Conditions<?>> getWhere() {
		return where;
	}
	/** 使用and连接的查询条件 */
	public void setWhere(List<Conditions<?>> where) {
		this.where = where;
	}
//	/** limit分页sql语句(不写select和where)(mysql/postgresql) */
//	public String getLimit() {
//		return limit;
//	}
//	/** limit分页sql语句(不写select和where)(mysql/postgresql) */
//	public void setLimit(String limit) {
//		this.limit = limit;
//	}
	/** order排序sql语句(不写select和where) */
	public String getOrderBy() {
		return orderBy;
	}
	/** order排序sql语句(不写select和where) */
	public void setOrderBy(String orderBy) {
		this.orderBy = orderBy;
	}
	/** group的sql语句(不写select和where) */
	public String getGroupBy() {
		return groupBy;
	}
	/** group的sql语句(不写select和where) */
	public void setGroupBy(String groupBy) {
		this.groupBy = groupBy;
	}
}
